package qc.module.cms.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.constants.QCConstant;
import qc.common.core.enums.CmsArticleStatusFlagEnum;
import qc.common.core.exception.QCPromptException;
import qc.common.core.utils.DateUtil;
import qc.module.cms.dto.article.ArticleDto;
import qc.module.cms.dto.article.ArticleQueryConditionDto;
import qc.module.cms.dto.article.ArticleQueryResultDto;
import qc.module.cms.dto.category.CategoryDto;
import qc.module.cms.dto.category.CategoryQueryConditionDto;
import qc.module.cms.dto.category.CategorySimpleDto;
import qc.module.cms.dto.display.*;
import qc.module.cms.dto.link.LinkCategoryDto;
import qc.module.cms.dto.link.LinkDto;
import qc.module.cms.dto.swipper.SwipperDto;
import qc.module.cms.entity.Article;
import qc.module.cms.mapper.ArticleMapper;
import qc.module.cms.repository.ArticleRepository;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * DisplayService
 *
 * @author QuCheng Tech
 * @since 2023/5/26
 */
@Service
public class DisplayService {
    private CategoryService categoryService;

    private ArticleRepository repository;

    @Autowired
    public void setArticleRepository(ArticleRepository repository) {
        this.repository = repository;
    }

    @Autowired
    public void setCategoryService(CategoryService categoryService) {
        this.categoryService = categoryService;
    }

    private CategorySwipperService categorySwipperService;

    @Autowired
    public void setCategorySwipperService(CategorySwipperService categorySwipperService) {
        this.categorySwipperService = categorySwipperService;
    }

    private ArticleService articleService;

    @Autowired
    public void setArticleService(ArticleService articleService) {
        this.articleService = articleService;
    }

    private LinkCategoryService linkCategoryService;

    @Autowired
    public void setLinkCategoryService(LinkCategoryService linkCategoryService) {
        this.linkCategoryService = linkCategoryService;
    }

    private LinkService linkService;

    @Autowired
    public void setLinkService(LinkService linkService) {
        this.linkService = linkService;
    }

    /**
     * 获取CMS的公用显示信息，包含栏目和二级栏目，链接分类和连接；信息均为可见状态
     *
     * @return qc.module.cms.dto.display.DisplayCommonInfoDto
     * @author QuCheng Tech
     * @since 2023/5/29
     */
    public DisplayCommonInfoDto getCmsCommonInfo() throws QCPromptException {
        DisplayCommonInfoDto result = new DisplayCommonInfoDto();

        //栏目信息
        List<DisplayCommonCategoryInfoDto> categories = new ArrayList<>();
        CategoryQueryConditionDto categoryQueryConditionDto = new CategoryQueryConditionDto();
        categoryQueryConditionDto.setIsall(false);
        categoryQueryConditionDto.setIsdept(false);
        categoryQueryConditionDto.setIsvisible(false);
        List<CategorySimpleDto> categorySimpleDtos = categoryService.queryListSimple(categoryQueryConditionDto, null);
        if (categorySimpleDtos != null && categorySimpleDtos.size() > 0x0) {
            //遍历一级栏目，获取一级栏目的下级集合
            List<CategorySimpleDto> rootCategories = categorySimpleDtos.stream().filter(p -> p.getPid() == 0x0).collect(Collectors.toList());
            if (rootCategories != null && rootCategories.size() > 0x0) {
                for (CategorySimpleDto level1CategoryDto : rootCategories) {
                    DisplayCommonCategoryInfoDto displayCommonCategoryInfoDto = new DisplayCommonCategoryInfoDto();
                    //设置栏目level为1
                    level1CategoryDto.setLevel(0x1);
                    //一级栏目信息
                    displayCommonCategoryInfoDto.setInfo(level1CategoryDto);
                    //二级栏目信息初始化
                    List<CategorySimpleDto> childCategories = new ArrayList<>();
                    List<CategorySimpleDto> level2Categories = categorySimpleDtos.stream().filter(p -> level1CategoryDto.getId() == (p.getPid())).collect(Collectors.toList());
                    if (level2Categories != null && level2Categories.size() > 0x0) {
                        //遍历二级栏目，添加到返回集合中
                        for (CategorySimpleDto level2CategoryDto : level2Categories) {
                            //设置栏目level为2
                            level2CategoryDto.setLevel(0x2);
                            childCategories.add(level2CategoryDto);
                        }
                    }
                    //二级栏目赋值
                    displayCommonCategoryInfoDto.setChilds(childCategories);

                    categories.add(displayCommonCategoryInfoDto);
                }
            }
        }
        result.setCategories(categories);

        //链接分类
        List<DisplayLinkCategoryInfoDto> linkCategories = new ArrayList<>();
        List<LinkCategoryDto> validLinkCategories = linkCategoryService.getAll(false);
        if (validLinkCategories != null && validLinkCategories.size() > 0x0) {
            for (LinkCategoryDto linkCat : validLinkCategories) {
                DisplayLinkCategoryInfoDto displayLinkCategoryInfoDto = new DisplayLinkCategoryInfoDto();
                displayLinkCategoryInfoDto.setInfo(linkCat);
                //获取分类中的链接
                List<LinkDto> linkDtos = linkService.getCategoryLinks(linkCat.getId(), false);
                if (linkDtos != null && linkDtos.size() > 0x0)
                    displayLinkCategoryInfoDto.setLinks(linkDtos);

                linkCategories.add(displayLinkCategoryInfoDto);
            }
        }
        result.setLinkcategories(linkCategories);

        return result;
    }

    /**
     * 获取指定栏目的信息，包括当前栏目信息、文章和下一级栏目和文字
     *
     * @param categoryDto 栏目DTO
     * @return qc.module.cms.dto.display.DisplayCategoryInfoDto
     * @author QuCheng Tech
     * @since 2023/5/29
     */
    public DisplayCategoryInfoDto getCmsCategoryAndArticleInfo(CategoryDto categoryDto) throws QCPromptException {
        //已经在调用处进行栏目信息的查询并赋值，在此方法中不再对传入的栏目信息有效性进行验证
        int categoryId = categoryDto.getId();
        //获取当前栏目的查询文章数量配置
        int articleCount = getCategoryQueryArticleCount(categoryDto);
        //当前栏目是否需要显示轮播图，需要显示轮播图时才进行轮播图查询
        //2023-10-12，栏目中的轮播图增加分组ID，用于区分是栏目中文章的轮播图还是横隔用的轮播图；
        //增加分组ID后不需要根据版面布局Json配置判断是否需要查询轮播图数据，固定将栏目中的所有轮播图数据均查询返回
        //2023-10-25，获取栏目轮播图（非横隔）显示的数量，用于查询轮播图数据
        int swipperCount = getCategoryNeedShowSwippersCount(categoryDto);
        
        //获取子栏目集合，从版面布局配置中获取，有可能是自己的下一级栏目信息，也有可能是自定义配置的子栏目信息
        List<CategoryDto> childCategoryDtos = getChildCategories(categoryDto);

        //初始化返回结果
        DisplayCategoryInfoDto result = new DisplayCategoryInfoDto();
        result.setCategory(categoryDto);

        //查询当前栏目下的TopN文章
        result.setArticles(articleService.getCategoryTopArticles(categoryId, articleCount));
        
        //查询当前栏目的轮播图配置
        //2023-10-12，轮播图增加分组ID后固定查询栏目中的所有轮播图信息
        //增加分组ID后不需要根据版面布局Json配置判断是否需要查询轮播图数据，固定将栏目中的所有轮播图数据均查询返回
        //2023-10-25，根据轮播图数量进行查询，如果数量大于0同时查询轮播图和横隔，如果数量为0仅需要查询横隔
        if (swipperCount > 0x0)
            result.setSwippers(categorySwipperService.getCategoryValidSwippersAndSeptums(categoryId, swipperCount));
        else
            result.setSwippers(categorySwipperService.getCategoryValidSeptums(categoryId));

        //查询下一级栏目--根据配置可能是下一级栏目也可能是自定义配置的栏目
        List<DisplayCategoryInfoDto> childCategories = new ArrayList<>();

        if (childCategoryDtos != null && childCategoryDtos.size() > 0x0) {
            //返回的下一级栏目信息中已有栏目信息，直接获取，不需要再次查询
            for (CategoryDto childCategoryDto : childCategoryDtos) {
                DisplayCategoryInfoDto childCategory = new DisplayCategoryInfoDto();
                childCategory.setCategory(childCategoryDto);
                //查询下一级栏目下的TopN文章
                int childCategoryId = childCategoryDto.getId();
                int childCategoryArticleCount = getCategoryQueryArticleCount(childCategoryDto);

                //查询当前栏目下的TopN条文章
                childCategory.setArticles(articleService.getCategoryTopArticles(childCategoryId, childCategoryArticleCount));
                
                //再下一级不需要查询轮播图,需要查询再下一级的子栏目和TopN文章
                //固定获取当前栏目的所有子栏目，不从版面布局配置中获取
                List<CategoryDto> subChildCategoryDtos = categoryService.getChildCategories(childCategoryId);
                if (CollectionUtils.isNotEmpty(subChildCategoryDtos)){
                    List<DisplayCategoryInfoDto> subChildCategories = new ArrayList<>();
                    
                    for (CategoryDto subChildCategoryDto : subChildCategoryDtos){
                        DisplayCategoryInfoDto subChildCategory = new DisplayCategoryInfoDto();
                        subChildCategory.setCategory(subChildCategoryDto);
                        //查询TopN文章
                        int subChildCategoryId = subChildCategoryDto.getId();
                        int subChildCategoryArticleCount = getCategoryQueryArticleCount(subChildCategoryDto);

                        //查询当前栏目下的TopN条文章
                        subChildCategory.setArticles(articleService.getCategoryTopArticles(subChildCategoryId,subChildCategoryArticleCount));
                        //再往下一级不需要查询
                        
                        subChildCategories.add(subChildCategory);
                    }
                    childCategory.setChilds(subChildCategories);
                }
                childCategories.add(childCategory);
            }
        }
        result.setChilds(childCategories);

        return result;
    }

    /**
     * 获取指定栏目Id的文章信息，包括当前栏目及当前栏目子级中的文章
     *
     * @param categoryId 栏目ID
     * @return qc.module.cms.dto.display.DisplayCategoryArticlesDto
     * @author QuCheng Tech
     * @since 2024/1/22
     */
    public DisplayCategoryArticlesDto getCmsCategoryArticles(Integer categoryId) throws QCPromptException {
        
        List<Integer> cids = new ArrayList<>();
        cids.add(categoryId);
        //获取当前栏目的子栏目的id集合
        List<CategoryDto> subCategories = categoryService.getChilds(categoryId,true);
        if (CollectionUtils.isNotEmpty(subCategories)){
            List<Integer> subCids = subCategories.stream().map(category -> category.getId()).collect(Collectors.toList());
            cids.addAll(subCids);
        }
        
        //获取当前栏目的查询文章数量配置
        CategoryDto categoryDto = categoryService.get(categoryId,true);
        Integer articleCount = getCategoryQueryArticleCount(categoryDto);
        
        //根据栏目id集合查询Top N条文章，不包含文章内容,文章有效状态--已发布
        List<ArticleDto> articleDtos = articleService.getCategoriesTopArticles(cids,articleCount);
        
        DisplayCategoryArticlesDto result = new DisplayCategoryArticlesDto();
        if (CollectionUtils.isNotEmpty(articleDtos))
            result.setArticles(articleDtos);
        return result;
    }

    /**
     * 获取指定栏目的子栏目集合
     * 根据栏目版面布局配置信息，可能为栏目的下一级子栏目，也可能为自定义配置的子栏目信息
     * 
     * @param categoryDto 父栏目信息
     * @return
     * @throws QCPromptException
     */
    private List<CategoryDto> getChildCategories(CategoryDto categoryDto) throws QCPromptException {
        //读取栏目中的版面布局配置信息和文章显示配置信息
        JSONObject categoryLayoutJsonObject = null;
        if (!StringUtils.isBlank(categoryDto.getLayout())) {
            Object convertJsonObject = JSON.parse(categoryDto.getLayout());
            if (convertJsonObject instanceof JSONObject) {
                categoryLayoutJsonObject = (JSONObject) convertJsonObject;
            }
        }
        //从当面版面布局配置中获取需要查询的栏目信息
        //栏目版面中显示的栏目ID集合，根据配置可为栏目的下一级子栏目，也可以是自定义配置
        //后面查询每个栏目的文章需要得到栏目的文章配置信息，对查询的子栏目进行记录
        boolean isChildCategories = true;
        List<CategoryDto> childCategoryDtos = new ArrayList<>();
        if (categoryLayoutJsonObject != null) {
            //显示的是栏目中的子栏目还是自定义配置的栏目
            isChildCategories = categoryLayoutJsonObject.getBooleanValue("child");
        }
        if (isChildCategories) {
            //获取当前栏目的下一级子栏目
            //如果是配置为显示下一级子栏目，
            childCategoryDtos = categoryService.getChilds(categoryDto.getId(), true);
            //子栏目中类型配置为外部链接的不需要显示
            if (childCategoryDtos != null && childCategoryDtos.size() > 0x0) {
                childCategoryDtos.removeIf(category -> category.getContent() != null && category.getContent().startsWith("http"));
            }
        } else {
            //配置的是自定义栏目布局，获取自定义的栏目ID集合
            JSONArray customChildCategoryIds = categoryLayoutJsonObject.getJSONArray("ids");
            if (customChildCategoryIds != null && customChildCategoryIds.size() > 0x0) {
                for (Object obj : customChildCategoryIds) {
                    try {
                        int id = Integer.parseInt(obj.toString());
                        //自定义栏目布局如果有设置栏目ID集合，根据结合进行栏目信息查询
                        CategoryDto childCategoryDto = categoryService.get(id, true);
                        if (childCategoryDto != null)
                            childCategoryDtos.add(childCategoryDto);
                    } catch (NumberFormatException ex) {
                    }
                }
            }
        }
        return childCategoryDtos;
    }

    /***
     * 获取栏目显示轮播图（非横隔）数量，要显示轮播图时默认数量为5
     *
     * @param categoryDto 栏目信息
     * @return int
     * @author QuCheng Tech
     * @since 2023/8/1
     */
    int getCategoryNeedShowSwippersCount(CategoryDto categoryDto) {
        if (categoryDto != null) {
            JSONObject categoryLayoutJsonObject = null;
            if (!StringUtils.isBlank(categoryDto.getLayout())) {
                Object convertJsonObject = JSON.parse(categoryDto.getLayout());
                if (convertJsonObject instanceof JSONObject) {
                    categoryLayoutJsonObject = (JSONObject) convertJsonObject;
                }
            }
            if (categoryLayoutJsonObject != null) {
                //轮播图配置
                JSONObject swipperJsonObject = categoryLayoutJsonObject.getJSONObject("swipper");
                if (swipperJsonObject != null) {
                    boolean swiperVisibleValue = swipperJsonObject.getBooleanValue("visible");
                    if (swiperVisibleValue) {
                        //要显示轮播图时，默认数量为5
                        int count = swipperJsonObject.getIntValue("count");
                        //数量必须在1~10之间
                        if (count < 0x1 || count > 10)
                            return 0x5;
                        return count;
                    }
                }
            }
        }

        //默认不显示轮播图，数量为0
        return 0x0;
    }

    /***
     * 获取栏目查询最新文章数量，如果没有配置返回默认值
     *
     * @param categoryDto 栏目信息
     * @return int
     * @author QuCheng Tech
     * @since 2023/8/1
     */
    int getCategoryQueryArticleCount(CategoryDto categoryDto) {
        if (categoryDto != null) {
            JSONObject categoryArticleJsonObject = null;
            if (!StringUtils.isBlank(categoryDto.getArticle())) {
                Object convertJsonObject = JSON.parse(categoryDto.getArticle());
                if (convertJsonObject instanceof JSONObject) {
                    categoryArticleJsonObject = (JSONObject) convertJsonObject;
                }
            }
            if (categoryArticleJsonObject != null) {
                String countStringValue = categoryArticleJsonObject.getString("count");
                if (!StringUtils.isBlank(countStringValue)) {
                    try {
                        int count = Integer.parseInt(countStringValue);
                        if (count > 0x0) {
                            //获取栏目中设置的查询文章数量；
                            return count;
                        }
                    } catch (NumberFormatException ex) {
                    }
                }
            }
        }
        return 0x6;
    }

    /**
     * 获取指定栏目的轮播图信息
     *
     * @param categoryId 栏目ID
     * @param count      数量，按ID值降序获取前N个
     * @return java.util.List<qc.module.cms.dto.swipper.SwipperDto>
     * @author QuCheng Tech
     * @since 2023/7/19
     */
    public List<SwipperDto> getCategorySwippers(int categoryId, int count) throws QCPromptException {
        return categorySwipperService.getCategoryValidSwippers(categoryId, count);
    }

    /**
     * 根据查询条件查询文章，查询条件中关键字必须指定，查询结果中的文章状态必须是已发布；
     *
     * @param condition: 查询条件
     * @return ArticleQueryResultDto 返回结果集
     * @author QcCheng Tech
     * @date 2023/7/21
     */
    public ArticleQueryResultDto queryArticles(ArticleQueryConditionDto condition) throws QCPromptException {
        if (condition == null)
            throw new QCPromptException("查询条件不能为空");
        //2023-10-13，修改查询关键字可以为空
        //if (StringUtils.isBlank(condition.getKeywords()))
        //    throw new QCPromptException("查询文章关键字不能为空");
        ArticleQueryResultDto result = new ArticleQueryResultDto();
        result.setTotal(0x0);
        result.setPages(0x1);
        result.setItems(new ArrayList<>());
        //查询数据
        LambdaQueryWrapper<Article> wrapper = new LambdaQueryWrapper<>();
        //指定为查询不包含内容列
        wrapper.select(Article::getId, Article::getCid, Article::getTitle, Article::getCover, Article::getCtype, Article::getKeywords, Article::getSource, Article::getAuthor, Article::getIntm, Article::getInuser, Article::getIndept, Article::getUptm, Article::getUpuser, Article::getFlag, Article::getTags, Article::getCount, Article::getAttachment);
        //查询条件--指定状态标记
        wrapper.eq(Article::getFlag, CmsArticleStatusFlagEnum.PUBLISH);
        //判断输入参数condition是否指定了栏目ID
        //2023-10-27，修改针对传入了栏目ID的处理：
        //根据传入的栏目ID获取栏目的版面布局配置JSON，根据显示子栏目--child、栏目ID集合--ids的配置进行判断处理
        //child==false，ids不为空时查询指定ids中的栏目集合，ids为空时查询当前栏目
        //child==true，查询当前栏目下的子级栏目集合
        if (!StringUtils.isBlank(condition.getCid())) {
            try {
                int categoryId = Integer.parseInt(condition.getCid());
                //获取当前栏目信息
                CategoryDto categoryDto = categoryService.get(categoryId, true);
                if (categoryDto != null) {
                    //读取栏目中的版面布局配置信息
                    JSONObject categoryLayoutJsonObject = null;
                    if (!StringUtils.isBlank(categoryDto.getLayout())) {
                        Object convertJsonObject = JSON.parse(categoryDto.getLayout());
                        if (convertJsonObject instanceof JSONObject) {
                            categoryLayoutJsonObject = (JSONObject) convertJsonObject;
                        }
                    }
                    if (categoryLayoutJsonObject != null) {
                        //显示的是栏目中的子栏目还是自定义配置的栏目
                        boolean isChildCategories = categoryLayoutJsonObject.getBooleanValue("child");
                        if (isChildCategories) {
                            //获取当前栏目的下一级子栏目
                            List<CategoryDto> childCategoryDtos = categoryService.getChilds(categoryId, true);
                            //如果指定为查询子级栏目，子级栏目没有时查询结果为空
                            if (childCategoryDtos != null && childCategoryDtos.size() > 0x0) {
                                List<Integer> categoryIds = childCategoryDtos.stream().map(p -> p.getId()).collect(Collectors.toList());
                                wrapper.in(Article::getCid, categoryIds);
                            } else {
                                //指定为查询子级栏目，子级栏目信息为空；指定查询的栏目ID为0
                                wrapper.eq(Article::getCid, 0x0);
                            }
                        } else {
                            //版面布局中配置不查询子级栏目，判断是否有配置的查询栏目ID集合
                            //配置的是自定义栏目布局，获取自定义的栏目ID集合
                            JSONArray customChildCategoryIds = categoryLayoutJsonObject.getJSONArray("ids");
                            if (customChildCategoryIds != null && customChildCategoryIds.size() > 0x0) {
                                List<Integer> categoryIds = new ArrayList<Integer>();
                                for (Object obj : customChildCategoryIds) {
                                    try {
                                        int id = Integer.parseInt(obj.toString());
                                        categoryIds.add(id);
                                    } catch (NumberFormatException ex) {
                                    }
                                }
                                if (categoryIds != null && categoryIds.size() > 0x0) {
                                    wrapper.in(Article::getCid, categoryIds);
                                } else {
                                    //没有配置查询的栏目ID结合，查询结果应为空；指定查询的栏目ID为0
                                    wrapper.eq(Article::getCid, 0x0);
                                }
                            } else {
                                //没有配置的查询栏目Id集合，查询当前栏目
                                wrapper.eq(Article::getCid, categoryId);
                            }
                        }
                    } else {
                        //没有配置当前栏目的版面布局JSON，查询当前栏目
                        wrapper.eq(Article::getCid, categoryId);
                    }
                } else {
                    //指定的栏目ID不存在时，查询结果应为空；指定条件为查询当前栏目ID
                    wrapper.eq(Article::getCid, categoryId);
                }
            } catch (NumberFormatException e) {
                // 转换错误
                throw new QCPromptException("栏目id转换出错");
            }
        }
        // 判断condition中的作者
        if (!StringUtils.isBlank(condition.getAuthor())) {
            // like 来源或作者
            wrapper.and(q -> {
                q.like(Article::getSource, condition.getAuthor()).or().like(Article::getAuthor, condition.getAuthor());
            });
        }
        // 判断condition中的时间
        if (StringUtils.isNotBlank(condition.getBegintm())) {
            try {
                Date date = DateUtil.parseDate(condition.getBegintm());
                wrapper.ge(Article::getIntm, date);
            } catch (Exception e) {
                // 时间转换错误，抛出自定义异常
                throw new QCPromptException("开始时间转换错误");
            }
        }
        if (StringUtils.isNotBlank(condition.getEndtm())) {
            try {
                Date date = DateUtil.parseDate(condition.getEndtm());
                wrapper.le(Article::getIntm, date);
            } catch (Exception e) {
                // 时间转换错误，抛出自定义异常
                throw new QCPromptException("结束时间转换错误");
            }
        }
        //判断是否指定了只查询有封面图片ID的文章
        if (condition.getHasCover() != null && condition.getHasCover().booleanValue() == true) {
            wrapper.isNotNull(Article::getCover);
            wrapper.gt(Article::getCover, 0x0);
        }
        // like 标题或关键字
        if (!StringUtils.isBlank(condition.getKeywords())) {
            wrapper.and(q -> {
                q.like(Article::getTitle, condition.getKeywords()).or().like(Article::getKeywords, condition.getKeywords());
            });
        }

        //排序
        //先根据标签降序，文章置顶时标签为8，可以保证置顶文章排在最前
        wrapper.orderByDesc(Article::getTags);
        //再按发布时间降序，最新发布的文章排在前面
        wrapper.orderByDesc(Article::getIntm);

        //分页查询 先构造一个Page对象
        int pageNum = QCConstant.PAGEING_DEFAULT_PAGE_NUM;
        int pageSize = QCConstant.PAGEING_DEFAULT_PAGE_SIZE;

        if (condition.getPage() > 0x0)
            pageNum = condition.getPage();
        if (condition.getPageSize() > 0x0)
            pageSize = condition.getPageSize();
        IPage<Article> page = new Page<>(pageNum, pageSize);
        IPage<Article> pageResult = repository.selectPage(page, wrapper);
        //获取查询结果
        result.setTotal(pageResult.getTotal());
        result.setPages(pageResult.getPages());
        List<Article> ens = pageResult.getRecords();
        if (ens != null && ens.size() > 0x0) {
            result.setItems(ArticleMapper.MAPPER.toDtoList(pageResult.getRecords()));
        }

        return result;
    }


}
